← All articles
AI & Design · Nov 20, 2026 · By Saagar

From Idea to Production: How I Design and Ship Real Code with Claude

For more than ten years my job ended at the handoff. Today I don’t hand off designs. I ship them.

Lines of colourful code on a dark screen

For more than ten years my job ended at the handoff. I’d polish the screens, annotate the states, export the specs, and then wait. Sometimes for weeks. Sometimes to see a build that looked like a distant cousin of what I’d designed.

That changed this year. I’ve stopped designing in Figma altogether. My whole workflow is now Claude and VS Code: I design directly in code, audit the UX, and ship. Dashboards, SaaS products, desktop apps, mobile apps and marketing sites, built and running in production.

This isn’t a story about AI replacing developers. It’s about a designer finally being able to close the gap between “this is how it should work” and “this is how it works.”

The Gap Every Designer Knows

Every designer has felt it. You spend days on spacing, hierarchy and micro-interactions, and some of that care gets lost in translation. Not because developers don’t care, but because a static file can’t carry every decision. Hover states get skipped. Empty states never get built. The 8px grid quietly becomes 10px.

I used to think the fix was better handoff documentation. It turned out the better fix was being able to build it myself, with someone who knows the code sitting next to me.

1. Design in Code, Not in a Design Tool

I no longer start in Figma. The thinking still comes first (user flows, information architecture, layout, hierarchy), but I work through it with Claude and go straight to a working screen in VS Code. The first version of the design is already real, running code, not a static mockup someone has to rebuild later.

Designing in the browser means I work with the real thing from day one: real screen sizes, real interactions, real content. I design every state up front (loading, empty, error, success) because I can see and click each one straight away.

2. Turn the Design System into Tokens

Before building a single screen, I have Claude set up the design system in code: CSS variables or a Tailwind config, a type scale, spacing, and base components like buttons, inputs and cards. Getting this foundation right means every screen after it inherits the same visual language automatically.

This is where my design background pays off most. I can tell straight away when a token is off, when a shadow is too heavy, or when a component’s padding doesn’t match the system.

3. Build Screen by Screen, Not All at Once

The biggest lesson I learned early: don’t ask for a whole app in one go. I build one screen or one feature at a time. I describe what it should do, who it’s for, and its states and edge cases, then review what comes back like I would review a junior developer’s pull request.

Small steps keep the code understandable and keep me in control of the decisions.

4. Run a UX Audit on Every Build

Without a mockup to compare against, the UX audit became my quality gate. Claude writes the code, but I decide whether it’s right. On every build I audit the experience in the browser: usability heuristics, visual hierarchy, consistency with the design system, copy, accessibility, and how it feels on mobile. I also have Claude run a structured audit alongside me, so nothing slips through just because I’ve stared at the screen too long.

Every finding becomes a specific fix. I don’t just say “fix it.” I say exactly what’s wrong: “the card’s top padding should be 24px to match the grid”, “this error message doesn’t tell the user what to do next”, or “this modal should trap focus and close on Escape.” The more specific I am, the better the result.

5. Make It Production Ready

A prototype that looks right is not the same as a product that works. Before anything ships, I go through the less glamorous checklist with Claude:

  • Responsive behaviour across screen sizes
  • Accessibility: contrast, keyboard navigation, focus states, screen reader labels
  • Real data, real authentication and proper error handling
  • Performance: image sizes, load times, unnecessary dependencies
  • Clean, readable code that another developer could pick up
  • Version control on GitHub, so every change is tracked

6. Ship It

Finally, deployment. For web products I use platforms like Vercel with Supabase for the backend and database. For other projects I’ve shipped desktop apps built with Tauri and mobile apps built with Flutter. Claude helps with the setup, configuration and debugging along the way, which used to be the point where side projects quietly died.

What I’ve Shipped This Way

Working like this, I’ve taken several products from idea to working software:

  • SaaS platforms for service businesses
  • Operations and management dashboards
  • Desktop apps for Mac
  • Mobile apps and games for Android
  • Client websites and landing pages

Each one started as an idea and a conversation. Each one is now real software.

What I Learned

Design skills matter more, not less. Claude can write code fast, but it can’t tell you whether a product feels right. Taste, hierarchy and understanding users are still the hard part, and they’re still the designer’s job.

Clear direction beats clever prompts. The best results came from treating Claude like a teammate: giving context, explaining the why, and being precise about what I wanted.

Understand what you ship. I don’t accept code I can’t roughly follow. I ask Claude to explain decisions, and over time I’ve learned far more about engineering than I ever did from handoff meetings.

Iteration is cheap now. Trying three versions of an interaction used to mean three rounds of mockups and three rounds with a developer. Now it takes an afternoon in VS Code, so I test ideas in the real product instead of debating them in static frames.

What This Means for Clients

For the people I work with, this changes the deal. Instead of a design file and a long wait for development, they get UX audits, working coded prototypes and production-ready front ends, all from the same person. Nothing gets lost in translation because there’s no translation.

The line between designer and developer is getting thinner. I don’t think designers need to become engineers. But designers who can take their own work all the way to production have a real advantage, and tools like Claude have made that possible for me in a way that wasn’t realistic a few years ago. If you’re a designer who’s always wanted to see your work live exactly as you imagined it, start small. Pick one screen. Build it. Ship it. Then do the next one.

Want to work together? See my work or get in touch.

Keep reading.

All articles →